package com.chiyoyo.multipay.framework.core.utils;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import lombok.extern.slf4j.Slf4j;

import java.io.File;
import java.io.IOException;
import java.util.Collections;
import java.util.List;

/**
 * @author chil
 * JSON 工具类
 */
@Slf4j
public class JsonUtils {

    public static final ObjectMapper objectMapper = new ObjectMapper();

    static {
        // 在这里配置ObjectMapper
        objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        // 忽略 null 值
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        // 解决 LocalDateTime 的序列化
        objectMapper.registerModules(new JavaTimeModule());
    }

    private JsonUtils() {
        // 私有构造函数防止实例化
    }

    /**
     * 对象转JSON字符串
     *
     * @param object 要转换的对象
     * @return JSON字符串，如果转换失败，返回null
     */
    public static String toJsonStr(Object object) {
        try {
            return objectMapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            log.error("Error converting object to JSON string", e);
            return null;
        }
    }

    /**
     * JSON字符串转对象
     *
     * @param jsonString JSON字符串
     * @param clazz      要转换的类
     * @param <T>        转换后的对象类型
     * @return 转换后的对象，如果转换失败，返回null
     */
    public static <T> T fromJsonStr(String jsonString, Class<T> clazz) {
        try {
            return objectMapper.readValue(jsonString, clazz);
        } catch (JsonProcessingException e) {
            log.error("Error converting JSON string to object", e);
            return null;
        }
    }

    /**
     * JSON字符串转对象列表
     *
     * @param jsonString JSON字符串
     * @param clazz      要转换的类
     * @param <T>        转换后的对象类型
     * @return 转换后的对象列表，如果转换失败，返回空列表
     */
    public static <T> List<T> fromJsonStrToList(String jsonString, Class<T[]> clazz) {
        try {
            T[] array = objectMapper.readValue(jsonString, clazz);
            return List.of(array);
        } catch (JsonProcessingException e) {
            log.error("Error converting JSON string to object list", e);
            return Collections.emptyList();
        }
    }

    /**
     * 对象写入JSON文件
     *
     * @param object   要写入的对象
     * @param filePath 文件路径
     * @return true 如果写入成功，否则返回 false
     */
    public static boolean writeToJsonFile(Object object, String filePath) {
        try {
            objectMapper.writeValue(new File(filePath), object);
            return true;
        } catch (IOException e) {
            log.error("Error writing object to JSON file", e);
            return false;
        }
    }

    /**
     * 从JSON文件读取对象
     *
     * @param filePath 文件路径
     * @param clazz    要转换的类
     * @param <T>      转换后的对象类型
     * @return 转换后的对象，如果读取失败，返回null
     */
    public static <T> T readFromJsonFile(String filePath, Class<T> clazz) {
        try {
            return objectMapper.readValue(new File(filePath), clazz);
        } catch (IOException e) {
            log.error("Error reading JSON file to object", e);
            return null;
        }
    }
}
